// Output created by jacc on Thu Apr 23 17:19:30 CEST 2009

package pl.kane.autokomp.livegenerator;

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;
import java.io.StringReader;

class AutoKompParser implements AutoKompParserTokens {
    private int yyss = 100;
    private int yytok;
    private int yysp = 0;
    private int[] yyst;
    protected int yyerrno = (-1);
    private String[] yysv;
    private String yyrv;

    public boolean parse() {
        int yyn = 0;
        yysp = 0;
        yyst = new int[yyss];
        yysv = new String[yyss];
        yytok = (token
                 );
    loop:
        for (;;) {
            switch (yyn) {
                case 0:
                    yyst[yysp] = 0;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 97:
                    yyn = yys0();
                    continue;

                case 1:
                    yyst[yysp] = 1;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 98:
                    yyn = yys1();
                    continue;

                case 2:
                    yyst[yysp] = 2;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 99:
                    yyn = yys2();
                    continue;

                case 3:
                    yyst[yysp] = 3;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 100:
                    yyn = yys3();
                    continue;

                case 4:
                    yyst[yysp] = 4;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 101:
                    yyn = yys4();
                    continue;

                case 5:
                    yyst[yysp] = 5;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 102:
                    yyn = yys5();
                    continue;

                case 6:
                    yyst[yysp] = 6;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 103:
                    yyn = yys6();
                    continue;

                case 7:
                    yyst[yysp] = 7;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 104:
                    yyn = yys7();
                    continue;

                case 8:
                    yyst[yysp] = 8;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 105:
                    yyn = yys8();
                    continue;

                case 9:
                    yyst[yysp] = 9;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 106:
                    yyn = yys9();
                    continue;

                case 10:
                    yyst[yysp] = 10;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 107:
                    yyn = yys10();
                    continue;

                case 11:
                    yyst[yysp] = 11;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 108:
                    yyn = yys11();
                    continue;

                case 12:
                    yyst[yysp] = 12;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 109:
                    yyn = yys12();
                    continue;

                case 13:
                    yyst[yysp] = 13;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 110:
                    yyn = yys13();
                    continue;

                case 14:
                    yyst[yysp] = 14;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 111:
                    switch (yytok) {
                        case '(':
                            yyn = 39;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 15:
                    yyst[yysp] = 15;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 112:
                    switch (yytok) {
                        case STRING:
                            yyn = 40;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 16:
                    yyst[yysp] = 16;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 113:
                    switch (yytok) {
                        case ';':
                            yyn = 25;
                            continue;
                        case '\n':
                            yyn = 26;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 17:
                    yyst[yysp] = 17;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 114:
                    switch (yytok) {
                        case '(':
                            yyn = 42;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 18:
                    yyst[yysp] = 18;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 115:
                    switch (yytok) {
                        case '(':
                            yyn = 43;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 19:
                    yyst[yysp] = 19;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 116:
                    switch (yytok) {
                        case '(':
                            yyn = 44;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 20:
                    yyst[yysp] = 20;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 117:
                    switch (yytok) {
                        case '(':
                            yyn = 45;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 21:
                    yyst[yysp] = 21;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 118:
                    switch (yytok) {
                        case ':':
                            yyn = 46;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 22:
                    yyst[yysp] = 22;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 119:
                    switch (yytok) {
                        case '=':
                            yyn = 47;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 23:
                    yyst[yysp] = 23;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 120:
                    switch (yytok) {
                        case '(':
                            yyn = 48;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 24:
                    yyst[yysp] = 24;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 121:
                    switch (yytok) {
                        case '(':
                            yyn = 49;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 25:
                    yyst[yysp] = 25;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 122:
                    yyn = yys25();
                    continue;

                case 26:
                    yyst[yysp] = 26;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 123:
                    yyn = yys26();
                    continue;

                case 27:
                    yyst[yysp] = 27;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 124:
                    yyn = yys27();
                    continue;

                case 28:
                    yyst[yysp] = 28;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 125:
                    yyn = yys28();
                    continue;

                case 29:
                    yyst[yysp] = 29;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 126:
                    yyn = yys29();
                    continue;

                case 30:
                    yyst[yysp] = 30;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 127:
                    yyn = yys30();
                    continue;

                case 31:
                    yyst[yysp] = 31;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 128:
                    yyn = yys31();
                    continue;

                case 32:
                    yyst[yysp] = 32;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 129:
                    yyn = yys32();
                    continue;

                case 33:
                    yyst[yysp] = 33;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 130:
                    yyn = yys33();
                    continue;

                case 34:
                    yyst[yysp] = 34;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 131:
                    yyn = yys34();
                    continue;

                case 35:
                    yyst[yysp] = 35;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 132:
                    yyn = yys35();
                    continue;

                case 36:
                    yyst[yysp] = 36;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 133:
                    yyn = yys36();
                    continue;

                case 37:
                    yyst[yysp] = 37;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 134:
                    yyn = yys37();
                    continue;

                case 38:
                    yyst[yysp] = 38;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 135:
                    yyn = yys38();
                    continue;

                case 39:
                    yyst[yysp] = 39;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 136:
                    switch (yytok) {
                        case ')':
                            yyn = 50;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 40:
                    yyst[yysp] = 40;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 137:
                    yyn = yys40();
                    continue;

                case 41:
                    yyst[yysp] = 41;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 138:
                    yyn = yys41();
                    continue;

                case 42:
                    yyst[yysp] = 42;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 139:
                    switch (yytok) {
                        case STRING:
                            yyn = 52;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 43:
                    yyst[yysp] = 43;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 140:
                    switch (yytok) {
                        case INTEGER:
                            yyn = 53;
                            continue;
                        case STRING:
                            yyn = 54;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 44:
                    yyst[yysp] = 44;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 141:
                    switch (yytok) {
                        case STRING:
                            yyn = 55;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 45:
                    yyst[yysp] = 45;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 142:
                    switch (yytok) {
                        case STRING:
                            yyn = 56;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 46:
                    yyst[yysp] = 46;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 143:
                    switch (yytok) {
                        case ';':
                            yyn = 25;
                            continue;
                        case '\n':
                            yyn = 26;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 47:
                    yyst[yysp] = 47;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 144:
                    switch (yytok) {
                        case INTEGER:
                            yyn = 59;
                            continue;
                        case STRING:
                            yyn = 60;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 48:
                    yyst[yysp] = 48;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 145:
                    switch (yytok) {
                        case INTEGER:
                            yyn = 61;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 49:
                    yyst[yysp] = 49;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 146:
                    switch (yytok) {
                        case INTEGER:
                            yyn = 63;
                            continue;
                        case STRING:
                            yyn = 64;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 50:
                    yyst[yysp] = 50;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 147:
                    switch (yytok) {
                        case ';':
                            yyn = 25;
                            continue;
                        case '\n':
                            yyn = 26;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 51:
                    yyst[yysp] = 51;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 148:
                    switch (yytok) {
                        case INTEGER:
                            yyn = 66;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 52:
                    yyst[yysp] = 52;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 149:
                    switch (yytok) {
                        case ')':
                            yyn = 67;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 53:
                    yyst[yysp] = 53;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 150:
                    switch (yytok) {
                        case ',':
                            yyn = 68;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 54:
                    yyst[yysp] = 54;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 151:
                    switch (yytok) {
                        case ',':
                            yyn = 69;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 55:
                    yyst[yysp] = 55;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 152:
                    switch (yytok) {
                        case ')':
                            yyn = 70;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 56:
                    yyst[yysp] = 56;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 153:
                    switch (yytok) {
                        case ')':
                            yyn = 71;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 57:
                    yyst[yysp] = 57;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 154:
                    yyn = yys57();
                    continue;

                case 58:
                    yyst[yysp] = 58;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 155:
                    yyn = yys58();
                    continue;

                case 59:
                    yyst[yysp] = 59;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 156:
                    yyn = yys59();
                    continue;

                case 60:
                    yyst[yysp] = 60;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 157:
                    switch (yytok) {
                        case '*':
                            yyn = 73;
                            continue;
                        case '+':
                            yyn = 74;
                            continue;
                        case '-':
                            yyn = 75;
                            continue;
                        case '/':
                            yyn = 76;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 61:
                    yyst[yysp] = 61;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 158:
                    switch (yytok) {
                        case ')':
                            yyn = 78;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 62:
                    yyst[yysp] = 62;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 159:
                    switch (yytok) {
                        case INTEGER:
                            yyn = 79;
                            continue;
                        case STRING:
                            yyn = 80;
                            continue;
                        case ')':
                            yyn = 81;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 63:
                    yyst[yysp] = 63;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 160:
                    switch (yytok) {
                        case STRING:
                        case ')':
                        case INTEGER:
                            yyn = yyr49();
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 64:
                    yyst[yysp] = 64;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 161:
                    switch (yytok) {
                        case STRING:
                        case ')':
                        case INTEGER:
                            yyn = yyr47();
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 65:
                    yyst[yysp] = 65;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 162:
                    yyn = yys65();
                    continue;

                case 66:
                    yyst[yysp] = 66;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 163:
                    yyn = yys66();
                    continue;

                case 67:
                    yyst[yysp] = 67;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 164:
                    switch (yytok) {
                        case ';':
                            yyn = 25;
                            continue;
                        case '\n':
                            yyn = 26;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 68:
                    yyst[yysp] = 68;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 165:
                    switch (yytok) {
                        case INTEGER:
                            yyn = 83;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 69:
                    yyst[yysp] = 69;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 166:
                    switch (yytok) {
                        case STRING:
                            yyn = 84;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 70:
                    yyst[yysp] = 70;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 167:
                    switch (yytok) {
                        case ';':
                            yyn = 25;
                            continue;
                        case '\n':
                            yyn = 26;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 71:
                    yyst[yysp] = 71;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 168:
                    switch (yytok) {
                        case ';':
                            yyn = 25;
                            continue;
                        case '\n':
                            yyn = 26;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 72:
                    yyst[yysp] = 72;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 169:
                    switch (yytok) {
                        case INTEGER:
                            yyn = 87;
                            continue;
                        case STRING:
                            yyn = 88;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 73:
                    yyst[yysp] = 73;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 170:
                    switch (yytok) {
                        case STRING:
                        case INTEGER:
                            yyn = yyr33();
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 74:
                    yyst[yysp] = 74;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 171:
                    switch (yytok) {
                        case STRING:
                        case INTEGER:
                            yyn = yyr31();
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 75:
                    yyst[yysp] = 75;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 172:
                    switch (yytok) {
                        case STRING:
                        case INTEGER:
                            yyn = yyr32();
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 76:
                    yyst[yysp] = 76;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 173:
                    switch (yytok) {
                        case STRING:
                        case INTEGER:
                            yyn = yyr34();
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 77:
                    yyst[yysp] = 77;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 174:
                    switch (yytok) {
                        case INTEGER:
                            yyn = 89;
                            continue;
                        case STRING:
                            yyn = 90;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 78:
                    yyst[yysp] = 78;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 175:
                    switch (yytok) {
                        case ';':
                            yyn = 25;
                            continue;
                        case '\n':
                            yyn = 26;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 79:
                    yyst[yysp] = 79;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 176:
                    switch (yytok) {
                        case STRING:
                        case ')':
                        case INTEGER:
                            yyn = yyr50();
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 80:
                    yyst[yysp] = 80;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 177:
                    switch (yytok) {
                        case STRING:
                        case ')':
                        case INTEGER:
                            yyn = yyr48();
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 81:
                    yyst[yysp] = 81;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 178:
                    switch (yytok) {
                        case ';':
                            yyn = 25;
                            continue;
                        case '\n':
                            yyn = 26;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 82:
                    yyst[yysp] = 82;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 179:
                    yyn = yys82();
                    continue;

                case 83:
                    yyst[yysp] = 83;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 180:
                    switch (yytok) {
                        case ')':
                            yyn = 93;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 84:
                    yyst[yysp] = 84;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 181:
                    switch (yytok) {
                        case ')':
                            yyn = 94;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 85:
                    yyst[yysp] = 85;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 182:
                    yyn = yys85();
                    continue;

                case 86:
                    yyst[yysp] = 86;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 183:
                    yyn = yys86();
                    continue;

                case 87:
                    yyst[yysp] = 87;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 184:
                    yyn = yys87();
                    continue;

                case 88:
                    yyst[yysp] = 88;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 185:
                    yyn = yys88();
                    continue;

                case 89:
                    yyst[yysp] = 89;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 186:
                    yyn = yys89();
                    continue;

                case 90:
                    yyst[yysp] = 90;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 187:
                    yyn = yys90();
                    continue;

                case 91:
                    yyst[yysp] = 91;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 188:
                    yyn = yys91();
                    continue;

                case 92:
                    yyst[yysp] = 92;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 189:
                    yyn = yys92();
                    continue;

                case 93:
                    yyst[yysp] = 93;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 190:
                    switch (yytok) {
                        case ';':
                            yyn = 25;
                            continue;
                        case '\n':
                            yyn = 26;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 94:
                    yyst[yysp] = 94;
                    yysv[yysp] = (yysval
                                 );
                    yytok = (yylex()
                            );
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 191:
                    switch (yytok) {
                        case ';':
                            yyn = 25;
                            continue;
                        case '\n':
                            yyn = 26;
                            continue;
                    }
                    yyn = 197;
                    continue;

                case 95:
                    yyst[yysp] = 95;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 192:
                    yyn = yys95();
                    continue;

                case 96:
                    yyst[yysp] = 96;
                    if (++yysp>=yyst.length) {
                        yyexpand();
                    }
                case 193:
                    yyn = yys96();
                    continue;

                case 194:
                    return true;
                case 195:
                    yyerror("stack overflow");
                case 196:
                    return false;
                case 197:
                    yyerror("syntax error");
                    return false;
            }
        }
    }

    protected void yyexpand() {
        int[] newyyst = new int[2*yyst.length];
        String[] newyysv = new String[2*yyst.length];
        for (int i=0; i<yyst.length; i++) {
            newyyst[i] = yyst[i];
            newyysv[i] = yysv[i];
        }
        yyst = newyyst;
        yysv = newyysv;
    }

    private int yys0() {
        switch (yytok) {
            case CLICK:
                return 14;
            case COUNTER:
                return 15;
            case ENDJAVA:
                return 16;
            case HOLD:
                return 17;
            case MOVE:
                return 18;
            case PRESS:
                return 19;
            case RELEASE:
                return 20;
            case STARTJAVA:
                return 21;
            case STRING:
                return 22;
            case WAIT:
                return 23;
            case WRITE:
                return 24;
            case ';':
                return 25;
            case '\n':
                return 26;
        }
        return 197;
    }

    private int yys1() {
        switch (yytok) {
            case ENDINPUT:
                return 194;
            case CLICK:
                return 14;
            case COUNTER:
                return 15;
            case ENDJAVA:
                return 16;
            case HOLD:
                return 17;
            case MOVE:
                return 18;
            case PRESS:
                return 19;
            case RELEASE:
                return 20;
            case STARTJAVA:
                return 21;
            case STRING:
                return 22;
            case WAIT:
                return 23;
            case WRITE:
                return 24;
            case ';':
                return 25;
            case '\n':
                return 26;
        }
        return 197;
    }

    private int yys2() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr19();
        }
        return 197;
    }

    private int yys3() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr23();
        }
        return 197;
    }

    private int yys4() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr21();
        }
        return 197;
    }

    private int yys5() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr9();
        }
        return 197;
    }

    private int yys6() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr1();
        }
        return 197;
    }

    private int yys7() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr11();
        }
        return 197;
    }

    private int yys8() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr3();
        }
        return 197;
    }

    private int yys9() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr5();
        }
        return 197;
    }

    private int yys10() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr13();
        }
        return 197;
    }

    private int yys11() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr7();
        }
        return 197;
    }

    private int yys12() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr17();
        }
        return 197;
    }

    private int yys13() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr15();
        }
        return 197;
    }

    private int yys25() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr51();
        }
        return 197;
    }

    private int yys26() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr52();
        }
        return 197;
    }

    private int yys27() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr20();
        }
        return 197;
    }

    private int yys28() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr24();
        }
        return 197;
    }

    private int yys29() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr22();
        }
        return 197;
    }

    private int yys30() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr10();
        }
        return 197;
    }

    private int yys31() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr2();
        }
        return 197;
    }

    private int yys32() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr12();
        }
        return 197;
    }

    private int yys33() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr4();
        }
        return 197;
    }

    private int yys34() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr6();
        }
        return 197;
    }

    private int yys35() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr14();
        }
        return 197;
    }

    private int yys36() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr8();
        }
        return 197;
    }

    private int yys37() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr18();
        }
        return 197;
    }

    private int yys38() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr16();
        }
        return 197;
    }

    private int yys40() {
        switch (yytok) {
            case '=':
                return 51;
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr35();
        }
        return 197;
    }

    private int yys41() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr40();
        }
        return 197;
    }

    private int yys57() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr39();
        }
        return 197;
    }

    private int yys58() {
        switch (yytok) {
            case LOOP:
            case ENDIF:
            case '=':
            case ')':
            case error:
            case '(':
            case BREAK:
            case INTEGER:
            case IF:
            case ENDLOOP:
            case ':':
            case ',':
                return 197;
            case '*':
                return 73;
            case '+':
                return 74;
            case '-':
                return 75;
            case '/':
                return 76;
        }
        return yyr25();
    }

    private int yys59() {
        switch (yytok) {
            case LOOP:
            case ENDIF:
            case '=':
            case ENDLOOP:
            case error:
            case IF:
            case BREAK:
            case INTEGER:
            case ':':
            case ',':
            case ')':
            case '(':
                return 197;
        }
        return yyr30();
    }

    private int yys65() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr46();
        }
        return 197;
    }

    private int yys66() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr36();
        }
        return 197;
    }

    private int yys82() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr42();
        }
        return 197;
    }

    private int yys85() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr41();
        }
        return 197;
    }

    private int yys86() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr43();
        }
        return 197;
    }

    private int yys87() {
        switch (yytok) {
            case LOOP:
            case ENDIF:
            case '=':
            case ENDLOOP:
            case error:
            case IF:
            case BREAK:
            case INTEGER:
            case ':':
            case ',':
            case ')':
            case '(':
                return 197;
        }
        return yyr29();
    }

    private int yys88() {
        switch (yytok) {
            case LOOP:
            case ENDIF:
            case '=':
            case ENDLOOP:
            case error:
            case IF:
            case BREAK:
            case INTEGER:
            case ':':
            case ',':
            case ')':
            case '(':
                return 197;
        }
        return yyr28();
    }

    private int yys89() {
        switch (yytok) {
            case LOOP:
            case ENDIF:
            case '=':
            case ENDLOOP:
            case error:
            case IF:
            case BREAK:
            case INTEGER:
            case ':':
            case ',':
            case ')':
            case '(':
                return 197;
        }
        return yyr27();
    }

    private int yys90() {
        switch (yytok) {
            case LOOP:
            case ENDIF:
            case '=':
            case ENDLOOP:
            case error:
            case IF:
            case BREAK:
            case INTEGER:
            case ':':
            case ',':
            case ')':
            case '(':
                return 197;
        }
        return yyr26();
    }

    private int yys91() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr45();
        }
        return 197;
    }

    private int yys92() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr44();
        }
        return 197;
    }

    private int yys95() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr37();
        }
        return 197;
    }

    private int yys96() {
        switch (yytok) {
            case STRING:
            case STARTJAVA:
            case HOLD:
            case RELEASE:
            case PRESS:
            case COUNTER:
            case MOVE:
            case ENDJAVA:
            case WRITE:
            case ';':
            case WAIT:
            case '\n':
            case ENDINPUT:
            case CLICK:
                return yyr38();
        }
        return 197;
    }

    private int yyr1() { // program : eol
        yysp -= 1;
        return 1;
    }

    private int yyr2() { // program : program eol
        yysp -= 2;
        return 1;
    }

    private int yyr3() { // program : move
        yysp -= 1;
        return 1;
    }

    private int yyr4() { // program : program move
        yysp -= 2;
        return 1;
    }

    private int yyr5() { // program : press
        yysp -= 1;
        return 1;
    }

    private int yyr6() { // program : program press
        yysp -= 2;
        return 1;
    }

    private int yyr7() { // program : startJava
        yysp -= 1;
        return 1;
    }

    private int yyr8() { // program : program startJava
        yysp -= 2;
        return 1;
    }

    private int yyr9() { // program : endJava
        yysp -= 1;
        return 1;
    }

    private int yyr10() { // program : program endJava
        yysp -= 2;
        return 1;
    }

    private int yyr11() { // program : hold
        yysp -= 1;
        return 1;
    }

    private int yyr12() { // program : program hold
        yysp -= 2;
        return 1;
    }

    private int yyr13() { // program : release
        yysp -= 1;
        return 1;
    }

    private int yyr14() { // program : program release
        yysp -= 2;
        return 1;
    }

    private int yyr15() { // program : write
        yysp -= 1;
        return 1;
    }

    private int yyr16() { // program : program write
        yysp -= 2;
        return 1;
    }

    private int yyr17() { // program : wait
        yysp -= 1;
        return 1;
    }

    private int yyr18() { // program : program wait
        yysp -= 2;
        return 1;
    }

    private int yyr19() { // program : click
        yysp -= 1;
        return 1;
    }

    private int yyr20() { // program : program click
        yysp -= 2;
        return 1;
    }

    private int yyr21() { // program : declareCounter
        yysp -= 1;
        return 1;
    }

    private int yyr22() { // program : program declareCounter
        yysp -= 2;
        return 1;
    }

    private int yyr23() { // program : counterAssigment
        yysp -= 1;
        return 1;
    }

    private int yyr24() { // program : program counterAssigment
        yysp -= 2;
        return 1;
    }

    private int yyr46() { // click : CLICK '(' ')' eol
        { outputFile.append("robot.mousePress(InputEvent.BUTTON1_MASK);\n");
                                                        outputFile.append("robot.delay(100);\n"); 
                                                        outputFile.append("robot.mouseRelease(InputEvent.BUTTON1_MASK);\n"); }
        yysv[yysp-=4] = yyrv;
        switch (yyst[yysp-1]) {
            case 0: return 2;
            default: return 27;
        }
    }

    private int yyr25() { // counterAssigment : STRING '=' counterExpr
        {
                        if (!counters.containsKey(yysv[yysp-3])) {
                         yyerror("Unknow counter: "+yysv[yysp-3]);
                        }
                outputFile.append(yysv[yysp-3]+"="+yysv[yysp-1]+";\n");
                }
        yysv[yysp-=3] = yyrv;
        switch (yyst[yysp-1]) {
            case 0: return 3;
            default: return 28;
        }
    }

    private int yyr26() { // counterExpr : STRING operator STRING
        {
                        if (!counters.containsKey(yysv[yysp-3])) {
                         yyerror("Unknow counter: "+yysv[yysp-3]);
                        }
                        if (!counters.containsKey(yysv[yysp-1])) {
                         yyerror("Unknow counter: "+yysv[yysp-1]);
                        }
                        yyrv=yysv[yysp-3]+yysv[yysp-2]+yysv[yysp-1];
                        }
        yysv[yysp-=3] = yyrv;
        return 58;
    }

    private int yyr27() { // counterExpr : STRING operator INTEGER
        {yyrv=yysv[yysp-3]+yysv[yysp-2]+yysv[yysp-1];}
        yysv[yysp-=3] = yyrv;
        return 58;
    }

    private int yyr28() { // counterExpr : counterExpr operator STRING
        {yyrv=yysv[yysp-3]+yysv[yysp-2]+yysv[yysp-1];}
        yysv[yysp-=3] = yyrv;
        return 58;
    }

    private int yyr29() { // counterExpr : counterExpr operator INTEGER
        {yyrv=yysv[yysp-3]+yysv[yysp-2]+yysv[yysp-1];}
        yysv[yysp-=3] = yyrv;
        return 58;
    }

    private int yyr30() { // counterExpr : INTEGER
        {yyrv=yysv[yysp-1];}
        yysv[yysp-=1] = yyrv;
        return 58;
    }

    private int yyr35() { // declareCounter : COUNTER STRING
        {counters.put(yysv[yysp-1],yysv[yysp-1]);outputFile.append("int "+yysv[yysp-1]+"=0;\n");}
        yysv[yysp-=2] = yyrv;
        return yypdeclareCounter();
    }

    private int yyr36() { // declareCounter : COUNTER STRING '=' INTEGER
        {counters.put(yysv[yysp-3],yysv[yysp-3]);outputFile.append("int "+yysv[yysp-3]+"="+yysv[yysp-1]+";\n");}
        yysv[yysp-=4] = yyrv;
        return yypdeclareCounter();
    }

    private int yypdeclareCounter() {
        switch (yyst[yysp-1]) {
            case 0: return 4;
            default: return 29;
        }
    }

    private int yyr40() { // endJava : ENDJAVA eol
        {startJavaCode=false;}
        yysv[yysp-=2] = yyrv;
        switch (yyst[yysp-1]) {
            case 0: return 5;
            default: return 30;
        }
    }

    private int yyr51() { // eol : ';'
        yysp -= 1;
        return yypeol();
    }

    private int yyr52() { // eol : '\n'
        yysp -= 1;
        return yypeol();
    }

    private int yypeol() {
        switch (yyst[yysp-1]) {
            case 93: return 95;
            case 81: return 92;
            case 78: return 91;
            case 71: return 86;
            case 70: return 85;
            case 67: return 82;
            case 50: return 65;
            case 46: return 57;
            case 16: return 41;
            case 1: return 31;
            case 0: return 6;
            default: return 96;
        }
    }

    private int yyr42() { // hold : HOLD '(' STRING ')' eol
        {outputFile.append("robot.hold(\""+yysv[yysp-3]+"\");\n");}
        yysv[yysp-=5] = yyrv;
        switch (yyst[yysp-1]) {
            case 0: return 7;
            default: return 32;
        }
    }

    private int yyr37() { // move : MOVE '(' INTEGER ',' INTEGER ')' eol
        { outputFile.append("robot.mouseMove("+yysv[yysp-5]+","+yysv[yysp-3]+");\n"); }
        yysv[yysp-=7] = yyrv;
        return yypmove();
    }

    private int yyr38() { // move : MOVE '(' STRING ',' STRING ')' eol
        { 
        
                        if (!counters.containsKey(yysv[yysp-5])) {
                         yyerror("Unknow counter: "+yysv[yysp-5]);
                        }
                        if (!counters.containsKey(yysv[yysp-3])) {
                         yyerror("Unknow counter: "+yysv[yysp-3]);
                        }
        outputFile.append("robot.mouseMove("+yysv[yysp-5]+","+yysv[yysp-3]+");\n"); 
        }
        yysv[yysp-=7] = yyrv;
        return yypmove();
    }

    private int yypmove() {
        switch (yyst[yysp-1]) {
            case 0: return 8;
            default: return 33;
        }
    }

    private int yyr31() { // operator : '+'
        {yyrv="+";}
        yysv[yysp-=1] = yyrv;
        return yypoperator();
    }

    private int yyr32() { // operator : '-'
        {yyrv="-";}
        yysv[yysp-=1] = yyrv;
        return yypoperator();
    }

    private int yyr33() { // operator : '*'
        {yyrv="*";}
        yysv[yysp-=1] = yyrv;
        return yypoperator();
    }

    private int yyr34() { // operator : '/'
        {yyrv="/";}
        yysv[yysp-=1] = yyrv;
        return yypoperator();
    }

    private int yypoperator() {
        switch (yyst[yysp-1]) {
            case 58: return 72;
            default: return 77;
        }
    }

    private int yyr41() { // press : PRESS '(' STRING ')' eol
        {outputFile.append("robot.press(\""+yysv[yysp-3]+"\");\n");}
        yysv[yysp-=5] = yyrv;
        switch (yyst[yysp-1]) {
            case 0: return 9;
            default: return 34;
        }
    }

    private int yyr47() { // anyString : STRING
        {yyrv=yysv[yysp-1];}
        yysv[yysp-=1] = yyrv;
        return 62;
    }

    private int yyr48() { // anyString : anyString STRING
        {yyrv=yysv[yysp-2]+" "+yysv[yysp-1];}
        yysv[yysp-=2] = yyrv;
        return 62;
    }

    private int yyr49() { // anyString : INTEGER
        {yyrv=yysv[yysp-1].toString();}
        yysv[yysp-=1] = yyrv;
        return 62;
    }

    private int yyr50() { // anyString : anyString INTEGER
        {yyrv=yysv[yysp-2]+" "+yysv[yysp-1].toString();}
        yysv[yysp-=2] = yyrv;
        return 62;
    }

    private int yyr43() { // release : RELEASE '(' STRING ')' eol
        {outputFile.append("robot.release(\""+yysv[yysp-3]+"\");\n");}
        yysv[yysp-=5] = yyrv;
        switch (yyst[yysp-1]) {
            case 0: return 10;
            default: return 35;
        }
    }

    private int yyr39() { // startJava : STARTJAVA ':' eol
        {startJavaCode=true;}
        yysv[yysp-=3] = yyrv;
        switch (yyst[yysp-1]) {
            case 0: return 11;
            default: return 36;
        }
    }

    private int yyr45() { // wait : WAIT '(' INTEGER ')' eol
        { outputFile.append("robot.delay("+yysv[yysp-3]+");\n"); }
        yysv[yysp-=5] = yyrv;
        switch (yyst[yysp-1]) {
            case 0: return 12;
            default: return 37;
        }
    }

    private int yyr44() { // write : WRITE '(' anyString ')' eol
        {outputFile.append("robot.write(\""+yysv[yysp-3]+"\");\n");}
        yysv[yysp-=5] = yyrv;
        switch (yyst[yysp-1]) {
            case 0: return 13;
            default: return 38;
        }
    }

    protected String[] yyerrmsgs = {
    };



  private void yyerror(String msg) {
    System.out.println("ERROR in line "+lineCounter+": " + msg);
  }

  private int c;

  /** Read a single input character from standard input.
   */
   private void nextChar() {
    if (c>=0) {
      try {
          c = reader.read();
      } catch (Exception e) {
        c = (-1);
      }
    }
  }

int lineCounter=1;
 Map counters = new HashMap();  
   int token;
  String yysval;
 StringReader reader;
 static StringBuffer outputFile=new StringBuffer();
 boolean startJavaCode = false;

  /** Read the next token and return the
   *  corresponding integer code.
   */
  int yylex() {
  
  if (startJavaCode) {
          boolean endJava = false;
          while (!endJava) {
         if (Character.isLetter((char)c)) {
                 StringBuffer value= new StringBuffer();
                 do {
                         value.append((char)c);
             nextChar();
           } while (Character.isLetterOrDigit((char)c));
                   yysval = value.toString();
           
           if (yysval.equalsIgnoreCase("ENDJAVA")) {
                   endJava=true;
                   startJavaCode=false;
           }
           else
                outputFile.append(yysval);
        
      }
      else   {
         outputFile.append((char)c);
         nextChar();
      }
          }
          return '\n';
  }
  else 
    for (;;) {
      // Skip whitespace
      while (c==' ' || c=='\t' || c=='\r') {
        nextChar();
      }
      if (c<0) {
        return (token=ENDINPUT);
      }
      switch (c) {
        case '+' : nextChar();
                   return token='+';
        case '-' : nextChar();
                   return token='-';
        case '*' : nextChar();
                   return token='*';
        case '/' : nextChar();
                   return token='/';
        case '(' : nextChar();
                   return token='(';
        case ')' : nextChar();
                   return token=')';
        case ';' : nextChar();
                   return token=';';
                case '\n' : nextChar(); {
                           lineCounter++;
                   return token='\n'; 
                   }
        case ',' : nextChar();
                           return token=',';                     
            case '=' : nextChar();
                           return token='=';
            case ':' : nextChar();
                           return token=':';                       
        default  : if (Character.isDigit((char)c)) {
                     int n = 0;
                       do {
                         n = 10*n + (c - '0');
                         nextChar();
                       } while (Character.isDigit((char)c));
                       yysval = (new Integer(n)).toString();
                       return token=INTEGER;
                                 } else if (Character.isLetter((char)c)) {
                                         StringBuffer value= new StringBuffer();
                                         do {
                                                 value.append((char)c);
                             nextChar();
                           } while (Character.isLetterOrDigit((char)c));
                                           yysval = value.toString();
                           
                           if (yysval.equalsIgnoreCase("MOVE"))
                                   return token=MOVE;
                           else if (yysval.equalsIgnoreCase("CLICK"))
                                   return token=CLICK;
                           else if (yysval.equalsIgnoreCase("WAIT"))
                                   return token=WAIT;
                           else if (yysval.equalsIgnoreCase("PRESS"))
                                   return token=PRESS;
                           else if (yysval.equalsIgnoreCase("WRITE"))
                                   return token=WRITE;
                           else if (yysval.equalsIgnoreCase("COUNTER"))
                                   return token=COUNTER;
                           else if (yysval.equalsIgnoreCase("HOLD"))
                                   return token=HOLD;      
                           else if (yysval.equalsIgnoreCase("RELEASE"))
                                   return token=RELEASE;
                           else if (yysval.equalsIgnoreCase("LOOP"))
                                   return token=LOOP;
                           else if (yysval.equalsIgnoreCase("ENDLOOP"))
                                   return token=ENDLOOP;
                           else if (yysval.equalsIgnoreCase("BREAK"))
                                   return token=BREAK;
                           else if (yysval.equalsIgnoreCase("IF"))
                                   return token=IF;
                           else if (yysval.equalsIgnoreCase("ENDIF"))
                                   return token=ENDIF;
                           else if (yysval.equalsIgnoreCase("STARTJAVA"))
                                   return token=STARTJAVA;
                           else if (yysval.equalsIgnoreCase("ENDJAVA"))
                                   return token=ENDJAVA;                                                                                                                                                                                                   
                           else if (yysval.equalsIgnoreCase("END"))
                                   return token=ENDINPUT;
                           else {
                               return token=STRING;
                             }
                     } else {
                       yyerror("Illegal character "+c);
                       nextChar();
                     }
      }
    }
  }
 public static String runParser(String body)  {
          AutoKompParser parser = new AutoKompParser();
          outputFile=new StringBuffer();
          try{
                    parser.reader = new StringReader(body);
                        outputFile.append("package pl.kane.autokomp.livegenerator; \n"+
                        "import pl.kane.autokomp.livegenerator.*; \n"+
                        "import java.awt.AWTException;\n"+
                        "import java.awt.event.InputEvent;\n"+
                        "import java.awt.event.KeyEvent;\n"+
                        "public class Program extends Generic{ \n"+
                        "\tpublic void execute()  throws AWTException { \n"+
                        "\t\tAutoKompRobot robot = new AutoKompRobot();");
                        
                    parser.nextChar(); // prime the character input stream
                    parser.yylex();    // prime the token input stream
                    parser.parse();    // parse the input
                    
                    outputFile.append("\t} \n" +
                                "}");
          }catch (Exception e){
                  parser.yyerror(e.getMessage());
            }
            return outputFile.toString();
  }
 public static void main(String[] args) {
          AutoKompParser.runParser("D:\\Moje_Projekty\\AutoKomp\\pl\\kane\\autokomp\\livegenerator\\test.ak2");
          System.out.println(outputFile.toString());
  }


}
